import { Injectable } from '@nestjs/common';
// import { UserService } from '../user/user.service';
import { resFormatMethod } from '../../utils/res-format';
// import { MENU_LIST } from './menu.data';
import { InjectRepository } from '@nestjs/typeorm';
import { Menu } from './menu.entity';
import { Repository } from 'typeorm';
@Injectable()
export class MenuService {
  constructor(
    // 注入menu这张表的数据库实体
    @InjectRepository(Menu)
    //menuRepository 是针对menu这张表的数据库实例
    private readonly menuRepository: Repository<Menu>
  ) {}
  // 获取全部路由
  async findAll() {
    const MENU_LIST = await this.menuRepository.find();
    // 将status转化成字符串给前端
    const result = MENU_LIST.map(item => ({
      ...item,
      status: item.status.toString(),
    }));
    return resFormatMethod(0, '获取路由成功', result);
  }
  async create(body: Menu) {
    // 参数验证
    if (!body.name || !body.path) {
      return resFormatMethod(1, '新增失败：菜单名称和路径不能为空', null);
    }

    // 如果新增的是子菜单（pid不为0），检查父菜单状态
    if (body.pid) {
      const parentMenu = await this.menuRepository.findOne({
        where: {
          id: body.pid,
        },
      });

      // 如果父菜单不存在或者是禁用状态，则设置子菜单为禁用
      if (!parentMenu || parentMenu.status === 0) {
        body.status = 0;
      }
    }

    // 设置默认值
    if (body.status === undefined) {
      body.status = body.pid > 0 ? 0 : 1; // 子菜单默认禁用，顶级菜单默认启用
    }

    return resFormatMethod(
      0,
      '新增路由成功',
      await this.menuRepository.save(body)
    );
  }
  async update(body: Menu) {
    /* 
    - 更新父菜单时，所有子菜单状态同步
    - 更新子菜单时，检查父菜单状态并同步
    - 当所有子菜单都禁用时，父菜单也禁用
    - 当有子菜单启用时，父菜单也启用  
    */
    // 参数验证
    if (!body.id) {
      return resFormatMethod(1, '更新失败：菜单ID不能为空', null);
    }

    // 获取当前菜单信息
    const currentMenu = await this.menuRepository.findOne({
      where: { id: body.id },
    });

    if (!currentMenu) {
      return resFormatMethod(1, '更新失败：菜单不存在', null);
    }

    // 获取所有菜单数据，用于联动判断
    const allMenus = await this.menuRepository.find();

    // 递归更新子菜单状态（无论多少层级）
    const updateChildrenRecursive = async (pid: number, status: number) => {
      const children = allMenus.filter(menu => menu.pid === pid);

      if (children.length > 0) {
        // 更新所有子菜单
        await this.menuRepository.update({ pid: pid }, { status });

        // 递归处理子菜单的子菜单
        for (const child of children) {
          await updateChildrenRecursive(child.id, status);
        }
      }
    };

    // 检查是否有子菜单（无论层级，只要有子菜单就是"父路由"）
    const hasChildren = allMenus.some(menu => menu.pid === body.id);

    if (hasChildren) {
      // 有子菜单的父路由更新 - 递归同步所有子菜单状态
      if (body.status !== undefined) {
        // 递归更新所有子菜单、子子菜单...状态（因为修改一个父路由，常规情况就是要同步它一下所有子路由的状态）
        await updateChildrenRecursive(body.id, body.status);
      }
    } else {
      // 叶子节点（无子菜单）的子路由更新
      if (body.status !== undefined && currentMenu.pid) {
        // 检查父路由状态，如果父路由禁用，则子路由必须禁用

        const parentMenu = allMenus.find(menu => menu.id === currentMenu.pid);

        // 父路由禁用，子路由强制禁用
        if (!parentMenu || parentMenu.status === 0) {
          body.status = 0;
        }
        // 如果子路由被启用，则同步启用父路由

        if (body.status === 1) {
          await this.menuRepository.update(
            { id: currentMenu.pid },
            { status: 1 }
          );
        }

        // 检查是否所有子路由都被禁用，如果是则禁用父路由
        if (body.status === 0) {
          const siblings = allMenus.filter(
            menu => menu.pid === currentMenu.pid
          );

          // 检查是否所有兄弟节点都被禁用（排除当前正在更新的这个）
          const allDisabled = siblings.every(
            menu => menu.id === body.id || menu.status === 0
          );

          // 如果所有子路由都被禁用，则禁用父路由
          if (allDisabled) {
            await this.menuRepository.update(
              { id: currentMenu.pid },
              { status: 0 }
            );
          }
        }
      }
    }

    // 更新当前菜单状态
    const updateResult = await this.menuRepository.update(body.id, body);

    return resFormatMethod(0, '更新路由成功', updateResult);
  }
  // 获取启用的路由（后续会增加role的判定进行筛选）
  async findEnabled() {
    const MENU_LIST = await this.menuRepository.find({
      where: {
        status: 1,
      },
    });
    // 将status转化成字符串给前端
    const result = MENU_LIST.map(item => ({
      ...item,
      status: item.status.toString(),
    }));
    return resFormatMethod(0, '获取启用的路由成功', result);
  }
}
